home *** CD-ROM | disk | FTP | other *** search
/ PC Graphics Unleashed / PC Graphics Unleashed.iso / ch03 / io.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-21  |  25.4 KB  |  991 lines
  1. /****************************************************************
  2. * FILE:    io.c
  3. * DESC:    These are the basic input/output routines. They include
  4. *        disk-handling and keyboard I/O.
  5. * 
  6. * HISTORY:    Created      3/11/1993
  7. * LAST CHANGED: 5/ 6/1993
  8. * 
  9. *    Copyright (c) 1993 by Scott Anderson
  10. *
  11. ****************************************************************/
  12.  
  13. /* ----------------------INCLUDES----------------------------- */
  14.  
  15. #include <conio.h>
  16. #include <stdio.h>
  17. #include <io.h>
  18. #include <dos.h>            /* for the mouse */
  19. #include <math.h>
  20. #include <graph.h>
  21. #include <malloc.h>
  22. #include <memory.h>
  23. #include <string.h>
  24.  
  25. #include "define.h"
  26.  
  27. /* ----------------------DEFINES------------------------------ */
  28.  
  29. /* 0-99 (for tweens) appended to name */
  30. #define MAX_NAME_SIZE    (8-2)    
  31.  
  32. /**** PCX constants ****/
  33. /* Set top 2 bits for the count bytes */
  34. #define C0                (0xc0)
  35. /* The inverse of C0: 0x3f = 63 */
  36. #define MAX_RUN            (0x3f)
  37. /* Signals a 256 color palette */
  38. #define PAL_CODE        12        
  39.  
  40. /* -----------------------MACROS------------------------------ */
  41.  
  42. /* ----------------------TYPEDEFS----------------------------- */
  43.  
  44. typedef struct {
  45.     char manufacturer;
  46.     char version;
  47.     char encoding;
  48.     char bperpixelperplane;
  49.     unsigned int xmin, ymin, xmax, ymax;
  50.     unsigned int hres, vres;
  51.     char rgbmap[3][16];
  52.     char reserved;
  53.     char nplanes;
  54.     unsigned int bytesperline;
  55.     unsigned int paletteinfo;
  56. }
  57. CORE_PCX_HEADER;
  58.  
  59. typedef struct {
  60.     CORE_PCX_HEADER pcx;
  61.     unsigned char filler[128-sizeof (CORE_PCX_HEADER)];
  62. }
  63. HEADER_PCX;
  64.  
  65. /* ----------------------PROTOTYPES--------------------------- */
  66.  
  67. char        lineAsk(char *name);
  68. void        setTextMode();
  69. void        setGraphicsMode();
  70. int            fixFilename(char *userName, char *fixedName,
  71.                             char *extension, int number);
  72. LINE_LIST    *loadLines(char *filename, char *extension);
  73. int            saveLines(char *filename, LINE_LIST *lineList,
  74.                             char *extension);
  75. LINKED_LIST    *appendName(LINKED_LIST *head, char *name);
  76. LINKED_LIST    *rootSequence(int argc, char *argv[]);
  77. int            waitForKey();
  78.  
  79. /* ----------------------GLOBAL DATA-------------------------- */
  80.  
  81. int     CurrentPal = 0;    /* ID of current palette */
  82.  
  83. int        Wait = 0;
  84. int     Key;
  85. int        EndWait = OFF;
  86.  
  87. /* from the last read file, used to save pic */
  88. static HEADER_PCX     Header;
  89.  
  90. /* Global values set from last picture loaded */
  91. int Xmin, Ymin, Xmax, Ymax;
  92.  
  93. /* no file output for NULL name */
  94. char    *OutFilename = NULL;
  95. long    TotalBytes;
  96.  
  97. int     Button;
  98. int        Keystroke;
  99.  
  100. /***************   The file handling routines   *****************/
  101.  
  102. /*****************************************************************
  103. * FUNC: int    saveScreen(PALETTE *pal)
  104. * 
  105. * DESC: Save the current screen with the given palette
  106. *****************************************************************/
  107.  
  108. int
  109. saveScreen(PALETTE *pal)
  110. {
  111.     static int        fileCount = 0;
  112.  
  113.     unsigned int    byteCount = 0;
  114.     unsigned char    lastColor;
  115.     unsigned char    color;
  116.     /* The number of bytes in a run */
  117.     unsigned char    num;
  118.  
  119.     int        index;
  120.     int        x, y;
  121.     /* big enough for number & '.PCX' */
  122.     char     pcxName[MAX_PATHLEN];
  123.     FILE     *fp;
  124.     char    *p;
  125.  
  126.     if (!OutFilename)    /* no file name on command line */
  127.         return 0;
  128.  
  129.     /* Create a numbered file name for output */
  130.     fileCount++;
  131.     fixFilename(OutFilename, pcxName, EXT_PCX, fileCount);
  132.  
  133.     /* Open the file and print the PCX file header */
  134.     if ((fp = fopen (pcxName, "wb")) == NULL)
  135.         quit (WRITE_OPEN_ERR, pcxName);
  136.     byteCount = fwrite (&Header, 1, sizeof (Header), fp);
  137.     if (byteCount != sizeof (Header))
  138.         quit (WRITE_ERR, pcxName);
  139.  
  140.     /* pack the the screen lines before writing them */
  141.     for (y = Ymin; y <= Ymax; y++) {
  142.         num = 1;        /* prime algorithm with the 1st pixel */
  143.         lastColor = _getpixel (Xmin, y);
  144.         for (x = Xmin + 1; x <= Xmax; x++) {
  145.             color = _getpixel (x, y);
  146.             if (color == lastColor) {
  147.                 num++;        /* Accumulate same-colored pixels */
  148.                 if (num == MAX_RUN) {
  149.                     byteCount += putBlock (num, lastColor, fp);
  150.                     num = 0;
  151.                 }
  152.             }
  153.             else {    /* This is a pixel of a different color */
  154.                 if (num) 
  155.                     byteCount += putBlock (num, lastColor, fp);
  156.                 lastColor = color;
  157.                 num = 1;
  158.             }
  159.         }
  160.         /* flush the last byte or batch of bytes on a line */
  161.         if (num)
  162.             byteCount += putBlock (num, lastColor, fp);
  163.     }
  164.     /* Finally, the color palette */
  165.     num = PAL_CODE;        /* Write out the palette code byte */
  166.     byteCount += writeByte (&num, fp);
  167.  
  168.     /* Write the color palette */
  169.     for (index = 0; index < COLORS;  index++) {
  170.         color = pal->c[index].r << 3;
  171.         byteCount += writeByte (&color, fp);
  172.         color = pal->c[index].g << 3;
  173.         byteCount += writeByte (&color, fp);
  174.         color = pal->c[index].b << 3;
  175.         byteCount += writeByte (&color, fp);
  176.     }
  177.     fclose (fp);
  178.     return byteCount;
  179. }
  180.  
  181. /*****************************************************************
  182. * FUNC: int    putBlock(unsigned char num, unsigned char color,
  183. *                                                    FILE *fp)
  184. * 
  185. * DESC: Write out the 2 or 1 byte block for Run Length Encoding.
  186. *****************************************************************/
  187.  
  188. int
  189. putBlock(unsigned char num, unsigned char color, FILE *fp)
  190. {
  191.     unsigned int byteCount = 0;
  192.  
  193.     /* Singlet colors with the top 2 bits set could be
  194.         confused with a count, so first write the one-count. */
  195.     if ((num > 1) || ((num == 1) && ((color & C0) == C0))) {
  196.         num |= C0;
  197.         byteCount += writeByte (&num, fp);
  198.     }
  199.     byteCount += writeByte (&color, fp);
  200.     return byteCount;
  201. }
  202.  
  203. /*****************************************************************
  204. * FUNC: int    writeByte(unsigned char *byte, FILE *fp)
  205. * 
  206. * DESC: Write one byte to the file and quit if there is an error.
  207. *****************************************************************/
  208.  
  209. int
  210. writeByte(unsigned char *byte, FILE *fp)
  211. {
  212.     int count;
  213.  
  214.     count = fwrite (byte, sizeof (char), 1, fp);
  215.     if (count != 1)
  216.         quit (WRITE_ERR, "");
  217.     return count;
  218. }
  219.  
  220. /*****************************************************************
  221. * FUNC: loadPicture (char *filename)
  222. * 
  223. * DESC: Read a PCX file from the disk into a buffer
  224. *****************************************************************/
  225.  
  226. PICTURE *loadPicture (char *filename)
  227. {
  228.     char         pcxName[MAX_PATHLEN];
  229.     FILE         *fp;
  230.     int            num, count;
  231.     PICTURE     *picture;
  232.     unsigned int        bytes_read;
  233.     unsigned char        byte;
  234.     unsigned char far     *bufptr;
  235.  
  236.     fixFilename(filename, pcxName, EXT_PCX, 0);
  237.  
  238.     fp = fopen(pcxName, "rb");
  239.     if (fp == NULL)
  240.         quit (READ_OPEN_ERR, pcxName);
  241.     picture = malloc(sizeof (*picture));
  242.     mustRead(fp, (char *) &Header, sizeof Header);
  243.  
  244.     Xmin = picture->xmin = Header.pcx.xmin;
  245.     Ymin = picture->ymin = Header.pcx.ymin;
  246.     Xmax = picture->xmax = Header.pcx.xmax;
  247.     Ymax = picture->ymax = Header.pcx.ymax;
  248.     picture->tall = Ymax - Ymin + 1;
  249.     picture->wide = Xmax - Xmin + 1;
  250.     picture->pal_id = 0;
  251.     if (picture->tall != MAX_TALL
  252.             || picture->wide != MAX_WIDE
  253.             || Header.pcx.bperpixelperplane != 8
  254.             || Header.pcx.nplanes != 1)
  255.         quit (WRONG_PCX_FILE, pcxName);
  256.     TotalBytes = picture->tall * (long) picture->wide;
  257.     TotalBytes = MIN(TotalBytes, MAX_BYTES);
  258.  
  259.     picture->pixmap = (unsigned char far *)
  260.                         _fmalloc((size_t) TotalBytes);
  261.     if (picture->pixmap == NULL)
  262.         return(NULL);
  263.     bufptr = picture->pixmap;
  264.     bytes_read = 0;
  265.  
  266.     while (getBlock(&byte, &count, fp) != EOF) {
  267.         if ((bytes_read += count) > TotalBytes)
  268.             break;
  269.         for (num = 0; num < count; num++)
  270.             *bufptr++ = byte;
  271.     }
  272.     if (Header.pcx.version == 5)
  273.         loadPalette(fp, &picture->pal); 
  274.     else
  275.         defaultPalette(&picture->pal);
  276.  
  277.     fclose(fp);
  278.     return picture;
  279. }
  280.  
  281. /*****************************************************************
  282. * FUNC: getBlock (unsigned char *byte, int *count, FILE *fp)
  283. * 
  284. * DESC: get a Run Length Encoded block.  It's either a byte or a
  285. *        string of bytes with a length given by count.
  286. *****************************************************************/
  287.  
  288. int
  289. getBlock (unsigned char *byte, int *count, FILE *fp)
  290. {
  291.     unsigned char input_byte;
  292.  
  293.     if (fread(&input_byte, sizeof(input_byte), 1, fp) != 1) 
  294.         return (EOF);
  295.     *count = 1;        /* so far */
  296.     if ((input_byte & C0) == C0) {
  297.         /* Top 2 bits on, data stream to follow */
  298.         /* mask out the byte count */
  299.         *count = input_byte & MAX_RUN;
  300.         mustRead(fp, &input_byte, 1);
  301.     }
  302.     *byte = input_byte;    /* return the byte */
  303.     return (0);        /* success */
  304. }
  305.  
  306. /*****************************************************************
  307. * FUNC: int    mustRead(FILE *fp, char *buf, int n)
  308. * 
  309. * DESC: Read bytes or quit.
  310. *****************************************************************/
  311.  
  312. int
  313. mustRead(FILE *fp, char *buf, int n)
  314. {
  315.     int nread;
  316.  
  317.     nread = fread(buf, sizeof(*buf), n, fp);
  318.     if (nread != n)
  319.         quit(READ_ERR, "");
  320. }
  321.     
  322. /*****************************************************************
  323. * FUNC: int    loadPalette(FILE *fp, PALETTE *palette)
  324. * 
  325. * DESC: Go to the end of the file and get the palette
  326. *****************************************************************/
  327.  
  328. loadPalette(FILE *fp, PALETTE *palette)
  329. {
  330.     unsigned char packed_pal[3*COLORS];
  331.     int        color, component;
  332.     int        red, green, blue;
  333.  
  334.     unsigned char input_byte;
  335.     fseek(fp, -(PALETTE_SIZE+1L), SEEK_END);    /* -1 on error */
  336.  
  337.     mustRead(fp, &input_byte, 1);
  338.     if (input_byte != PAL_CODE) {
  339.         printf("The color palette is missing!\n");
  340.         return (ERROR);
  341.     }
  342.     mustRead(fp, packed_pal, sizeof packed_pal);
  343.     for (component = 0, color = 0;
  344.             component < COMPS*COLORS; component += COMPS) {
  345.         palette->c[color].r = packed_pal[component+0]>>3;
  346.         palette->c[color].g = packed_pal[component+1]>>3;
  347.         palette->c[color].b = packed_pal[component+2]>>3;
  348.         color++;
  349.     }
  350.     palette->c[255].r = 0x1f;
  351.     palette->c[255].g = 0x1f;
  352.     palette->c[255].b = 0x1f;
  353.     return (0);
  354. }
  355.  
  356. /*****************************************************************
  357. * FUNC: int    freePicture(PICTURE *pic)
  358. * 
  359. * DESC: Free the memory allocated for this image.
  360. *****************************************************************/
  361.  
  362. int
  363. freePicture(PICTURE *pic)
  364. {
  365.     _ffree(pic->pixmap);
  366.     free(pic);
  367. }
  368.  
  369. /*****************************************************************
  370. * FUNC: LINE_LIST    *loadLines(char *filename, char *extension);
  371. * 
  372. * DESC: allocate and fill in LINE_LIST structure from file
  373. *****************************************************************/
  374.  
  375. LINE_LIST
  376. *loadLines(char *filename, char *extension)
  377. {
  378.     char        lineName[MAX_PATHLEN];
  379.     FILE        *fp;
  380.     char       *p;
  381.     LINE_LIST  *lineList;
  382.     int        number;
  383.     int        i;
  384.  
  385.     lineList = malloc(sizeof (*lineList));
  386.     lineList->number = 0;
  387.  
  388.     /* condition the filename to be a line list file name */
  389.     fixFilename(filename, lineName, extension, 0);
  390.     lineList->filename = strdup(lineName);
  391.  
  392.     fp = fopen(lineName, "r");
  393.     if (fp == NULL)
  394.         return lineList;
  395.  
  396.     if (fscanf(fp, "%d\n", &number) != 1
  397.                         || number < 1 || number > MAX_LINES) {
  398.         fclose(fp);
  399.         return lineList;
  400.     }
  401.  
  402.     lineList->number = number;
  403.     for(i=0;i<number;i++) {
  404.         if (fscanf(fp, "%d %d %d %d\n",
  405.                         &lineList->line[i].p[0].x,
  406.                         &lineList->line[i].p[0].y,
  407.                         &lineList->line[i].p[1].x,
  408.                         &lineList->line[i].p[1].y) != 4)
  409.             quit (READ_CONTENTS_ERR, lineName);
  410.         lineList->line[i].p[0].x = clip(lineList->line[i].p[0].x,
  411.                                         0, MAX_WIDE);
  412.         lineList->line[i].p[0].y = clip(lineList->line[i].p[0].y,
  413.                                         0, MAX_TALL);
  414.         lineList->line[i].p[1].x = clip(lineList->line[i].p[1].x,
  415.                                         0, MAX_WIDE);
  416.         lineList->line[i].p[1].y = clip(lineList->line[i].p[1].y,
  417.                                         0, MAX_TALL);
  418.         
  419.     }
  420.     fclose(fp);
  421.     return lineList;
  422. }
  423.  
  424. /*****************************************************************
  425. * FUNC: saveLines(char *filename, LINE_LIST *lineList,
  426. *                                                char *extension);
  427. * 
  428. * DESC: save lineList to a file
  429. *****************************************************************/
  430.  
  431. saveLines(char *filename, LINE_LIST *lineList, char *extension)
  432. {
  433.     /* big enough for number & '.PCX' */
  434.     char     lineName[MAX_PATHLEN];
  435.     FILE     *fp;
  436.     char    *p;
  437.     int     i;
  438.  
  439.     /* condition the filename to be a line list file name */
  440.     strcpy (lineName, filename);
  441.     strupr (lineName);
  442.     p= strstr(lineName, ".");
  443.     if (p == NULL)
  444.         p = lineName + strlen(lineName);
  445.     strcat(p, extension);        /* add extension, it's needed */
  446.  
  447.     fp = fopen(lineName, "w");
  448.     if (fp == NULL)
  449.         quit (WRITE_ERR, lineName);
  450.  
  451.     fprintf(fp, "%d\n", lineList->number);
  452.     for(i=0;i<lineList->number;i++) {
  453.         fprintf(fp, "%d %d %d %d\n",
  454.                     lineList->line[i].p[0].x,
  455.                     lineList->line[i].p[0].y,
  456.                     lineList->line[i].p[1].x,
  457.                     lineList->line[i].p[1].y);
  458.     }
  459.     fclose(fp);
  460. }
  461.  
  462. /*****************************************************************
  463. * FUNC: LINKED_LIST    *rootSequence(int argc, char *argv[])
  464. * 
  465. * DESC: Process argument list and return a sequence of pcx files
  466. *****************************************************************/
  467.  
  468. LINKED_LIST
  469. *rootSequence(int argc, char *argv[])
  470. {
  471.     LINKED_LIST *head = NULL;
  472.     int arg, loaded, i;
  473.     char filename[100];
  474.  
  475.     for (arg = 1; arg < argc; arg++) {
  476.         if (fixFilename(argv[arg], filename, EXT_PCX, 0))
  477.             head = appendName(head, filename);
  478.         else {
  479.             loaded = 0;
  480.             for(i=1;i<MAX_TWEENS;i++) {
  481.                 fixFilename(argv[arg], filename, EXT_PCX, i);
  482.                 if(_access(filename, 4) == 0) {
  483.                     head = appendName(head, filename);
  484.                     loaded = 1;
  485.                 }
  486.                 else if (loaded == 1)
  487.                     return head;  /* a break in the sequence */
  488.             }
  489.             /* didn't find a sequence, try using EXT_PCX */
  490.             fixFilename(argv[arg], filename, EXT_PCX, 0);
  491.             head = appendName(head, filename);
  492.         }
  493.     }
  494.     return head;
  495. }
  496.  
  497. /*****************************************************************
  498. * FUNC: LINKED_LIST    *appendName(LINKED_LIST *head, char *name)
  499. * 
  500. * DESC: add a data item to the end of the linked list
  501. *****************************************************************/
  502.  
  503. LINKED_LIST
  504. *appendName(LINKED_LIST *head, char *name)
  505. {
  506.     LINKED_LIST *l;
  507.     LINKED_LIST *end;
  508.  
  509.     l = (LINKED_LIST *) malloc(sizeof (LINKED_LIST));
  510.     l->str = strdup(name);
  511.      l->next = NULL;
  512.  
  513.     if (head == NULL)
  514.         return l;
  515.  
  516.     /* find guy that points to end */
  517.     for(end=head; end->next; end=end->next);
  518.     end->next = l;
  519.     return head;
  520. }
  521.  
  522. /*****************************************************************
  523. * FUNC: int fixFilename(char *userName, char *fixedName,
  524. *                                    char *extension, int number)
  525. * 
  526. * DESC: Create a valid filename with correct extension & number.
  527. *       Returns true if the userName had asn extension at end
  528. *****************************************************************/
  529.  
  530. int
  531. fixFilename(char *userName, char *fixedName, char *extension,
  532.                                                     int number)
  533. {
  534.     char *p;
  535.     char localbuf[100];
  536.     int  extensionFound;
  537.     
  538.     strcpy (localbuf, userName);
  539.     p = localbuf + strlen(localbuf) - 4;
  540.     /* extension is there */
  541.     extensionFound = strcmpi(p, extension) == 0;
  542.     if (extensionFound)
  543.         *p = '\0';
  544.     if (number)
  545.         sprintf(fixedName, "%s%d%s", localbuf, number, extension);
  546.     else
  547.         sprintf(fixedName, "%s%s", localbuf, extension);
  548.     return extensionFound;
  549. }
  550.  
  551. /***   These are the color and the screen handling routines   ***/
  552.  
  553. /*****************************************************************
  554. * FUNC: int    setPalette(PALETTE *palette)
  555. * 
  556. * DESC: Set the 256 colors in the palette, using the output ports
  557. *****************************************************************/
  558.  
  559. setPalette(PALETTE *palette)
  560. {
  561.     int        color;
  562.  
  563.     for (color = 0; color < COLORS; color++) {
  564.         _outp (0x3c7, color-1);
  565.         _outp (0x3c9, palette->c[color].r << 1);
  566.         _outp (0x3c9, palette->c[color].g << 1);
  567.         _outp (0x3c9, palette->c[color].b << 1);
  568.     }
  569. }
  570.  
  571. /*****************************************************************
  572. * FUNC: int    defaultPalette(PALETTE *palette)
  573. * 
  574. * DESC: Create a gray-scale palette as a default
  575. *****************************************************************/
  576.  
  577. defaultPalette(PALETTE *palette)
  578. {
  579.     int i;
  580.     long j;
  581.     long k;
  582.  
  583.     for (i=0;i<COLORS;i++) {
  584.         j = i & 0x1f;
  585.         palette->c[i].r = palette->c[i].g = palette->c[i].b = j;
  586.     }
  587. }
  588. /*****************************************************************
  589. * FUNC: int    displayPicture(PICTURE *picture)
  590. * 
  591. * DESC: set the video mode & palette, then draw from the buffer
  592. *        to the screen.
  593. *****************************************************************/
  594.  
  595. displayPicture(PICTURE *picture)
  596. {
  597.     int x, y, xb, yb;
  598.  
  599.     if (picture->pal_id == 0) {    /* need to define palette */
  600.         picture->pal_id = paletteID(&picture->pal);
  601.     }
  602.     if (CurrentPal != picture->pal_id) {
  603.         setPalette(&picture->pal);
  604.         CurrentPal = picture->pal_id;
  605.     }
  606.     displayNoPal(picture);    
  607. }
  608.  
  609. /*****************************************************************
  610. * FUNC: int    displayNoPal(PICTURE *picture)
  611. * 
  612. * DESC: display a picture without messing with the palette
  613. *****************************************************************/
  614.  
  615. int
  616. displayNoPal(PICTURE *picture)
  617. {
  618.     /* This is the memory address of the VGA screen */    
  619.     unsigned char far *screen = (unsigned char far *) 0xa0000000;
  620.     unsigned char far *bufptr = picture->pixmap;
  621.  
  622.     _fmemcpy (screen, bufptr, (unsigned int) MAX_BYTES);
  623.     wait(Wait);
  624. }
  625.  
  626. /*****************************************************************
  627. * FUNC: int    paletteID(PALETTE *pal)
  628. * 
  629. * DESC: return a unique id for each unique palette
  630. *****************************************************************/
  631.  
  632. int
  633. paletteID(PALETTE *pal)
  634. {
  635.     static PALETTE *definedPals[MAX_FILES];
  636.     static int npals = 0;
  637.     int i;
  638.  
  639.     for (i = 0; i < npals; i++) {
  640.         if (samePal(definedPals[i], pal))
  641.             return i+1;
  642.     }
  643.     definedPals[npals] = pal;
  644.     npals++;
  645.     return npals;
  646. }
  647.     
  648. /*****************************************************************
  649. * FUNC: int    samePal(PALETTE *p1, PALETTE *p2)
  650. * 
  651. * DESC: return 1 if same exact palettes, 0 otherwise
  652. *****************************************************************/
  653.  
  654. int
  655. samePal(PALETTE *p1, PALETTE *p2)
  656. {
  657.     int index;
  658.  
  659.     for (index = 0; index < COLORS; index++) {
  660.         if (p1->c[index].r != p2->c[index].r) return 0;
  661.         if (p1->c[index].g != p2->c[index].g) return 0;
  662.         if (p1->c[index].b != p2->c[index].b) return 0;
  663.     }
  664.     return 1;
  665. }
  666.  
  667. /*****************************************************************
  668. * FUNC: int    drawPalette()
  669. * 
  670. * DESC: Draw the 256 colors of the current palette in the top
  671. *        left of the screen.
  672. *****************************************************************/
  673.  
  674. int
  675. drawPalette()
  676. {
  677. #define BT 4    /* block tall */
  678. #define BW 6    /* block wide */
  679.  
  680.     int x, y, xb, yb;
  681.  
  682.     for (xb = 0; xb < 16; xb++) {
  683.         for (yb = 0; yb < 16; yb++) {
  684.             for (x = xb*BW; x < (xb*BW + BW); x++) {
  685.                 for (y = yb*BT; y < (yb*BT + BT); y++) {
  686.                     _setcolor(yb * 16 + xb);
  687.                     _setpixel (x, y);
  688.                     
  689.                 }
  690.             }
  691.         }
  692.     }
  693. }
  694.  
  695. /********************   The mouse routines   ********************/
  696.  
  697. /*****************************************************************
  698. * FUNC: int    initMouse()
  699. * 
  700. * DESC: Initialize the mouse and quit if a driver isn't present.
  701. *****************************************************************/
  702.  
  703. #define MOUSE 0x33
  704.  
  705. int
  706. initMouse()
  707. {
  708.     union _REGS regs;
  709.     struct _SREGS sregs;
  710.     regs.x.ax = 0x3533;
  711.     _intdosx(®s, ®s, &sregs);
  712.     if((regs.x.bx | sregs.es ) == 0)
  713.         quit(MOUSE_ERR, "");
  714.     regs.x.ax = 0;
  715.     _int86(MOUSE, ®s, ®s);
  716. }
  717.  
  718. /*****************************************************************
  719. * FUNC: int    hideMouse()
  720. * 
  721. * DESC: Hide the mouse cursor before we draw anything.
  722. *        This use the chunk of screen saved by showMouse.
  723. *****************************************************************/
  724.  
  725. int
  726. hideMouse()
  727. {
  728.     union _REGS regs;
  729.  
  730.     regs.x.ax = 0x02;
  731.     _int86(MOUSE, ®s, ®s);
  732. }
  733.  
  734. /*****************************************************************
  735. * FUNC: int    showMouse()
  736. * 
  737. * DESC: Redisplay the mouse cursor after drawing something on the
  738. *        screen. Save the chunk of screen under the cursor for
  739. *        hideMouse.
  740. *****************************************************************/
  741.  
  742. int
  743. showMouse()
  744. {
  745.     union _REGS regs;
  746.  
  747.     regs.x.ax = 0x01;
  748.     _int86(MOUSE, ®s, ®s);
  749. }
  750.  
  751. /*****************************************************************
  752. * FUNC: int    mousePos(int *x, int *y)
  753. * 
  754. * DESC: Return the x,y coordinates of the mouse and any
  755. *        button or keystroke.
  756. *****************************************************************/
  757.  
  758. #define KEYHIT    0x0b    /* Check the keyboard */
  759. #define STDIN     0x07      /* Read a char from standard input */
  760.  
  761. int
  762. mousePos(int *x, int *y)
  763. {
  764.     union _REGS regs;
  765.     char *buttons;
  766.     int keystroke;
  767.  
  768.     regs.h.ah = KEYHIT;
  769.     _intdos(®s, ®s);
  770.     keystroke = (regs.h.al == 0xff) ? KEYPRESS : 0;
  771.     if (keystroke) {
  772.         regs.h.ah = STDIN;
  773.         _intdos(®s, ®s);    /* STDIN */
  774.         if (Key = regs.h.al == ESC)
  775.             quit(0,"");            /* quit on Esc key */
  776.     }
  777.     regs.x.ax = 0x03;
  778.     _int86(MOUSE, ®s, ®s);
  779.     *x = regs.x.cx/2;            /* store the x & y coordinates */
  780.     *y = regs.x.dx;
  781.     /* return:    0 = none
  782.                    1 = left
  783.                    2 = right
  784.                 4 = keypress */
  785.     return (Button = (regs.x.bx & 0x03) | keystroke);
  786. }
  787.  
  788. /******************   A few utility routines   ******************/
  789.  
  790. /*****************************************************************
  791. * FUNC: int    waitForKey()
  792. * 
  793. * DESC: Wait for a key to be pressed, then return the key.
  794. *****************************************************************/
  795.  
  796. int
  797. waitForKey()
  798. {
  799.     int key;
  800.  
  801.     while (!_kbhit());
  802.     key = _getch();
  803.     if (key == ESC)
  804.         quit(0,"");
  805.     return (key); /* clear buffer and return keystroke */
  806. }
  807.  
  808. /*****************************************************************
  809. * FUNC: char    lineAsk(char *name)
  810. * 
  811. * DESC: Ask the users if they want to use the pre-defined lines.
  812. *****************************************************************/
  813.  
  814. char
  815. lineAsk(char *name)
  816. {
  817.     char c;
  818.  
  819.     setTextMode();
  820.  
  821.     _settextposition(VTAB, HTAB);
  822.     printf ("The picture '%s' has some pre-defined", name);
  823.     _settextposition(VTAB+2, HTAB);
  824.     printf ("control lines. Would you like to use them?");
  825.     _settextposition(VTAB+4, HTAB+8);
  826.     printf ("(Y/N):");
  827.     c = getche();
  828.     if (c == ESC)
  829.         quit(NO_ERROR, "");
  830.     c = toupper(c);
  831.     return c;
  832. }
  833.  
  834. /*****************************************************************
  835. * FUNC: int    quitCheck()
  836. * 
  837. * DESC: Check keyboard. If there is no key waiting, return 0,
  838. *        for OK. If a number from 1-9 is typed, change the wait
  839. *        between frames. Otherwise, the user wants to quit,
  840. *        so return 1.
  841. *****************************************************************/
  842.  
  843. int
  844. quitCheck()
  845. {
  846.     static int spaceWait = OFF;
  847.  
  848.     if (spaceWait) {
  849.         Key = getch();
  850.         if (Key != ' ')
  851.             spaceWait = OFF;
  852.     }
  853.     else if (_kbhit()) {
  854.         Key = _getch();
  855.         if (Key == ' ') {
  856.             /* turn on space bar stepping */
  857.             spaceWait = ON;
  858.             /* pause for space key */
  859.             Key = _getch();
  860.         }
  861.         if (Key == ESC || Key == 'q' || Key == 'Q')
  862.             return 1;                      /* a quit key */
  863.         if (Key == 'E' || Key == 'e')
  864.             EndWait ^= ON;                /* toggles on and off */
  865.         else if (Key >= '1' && Key <= '9')
  866.             Wait = '9' - Key;
  867.     }
  868.     return 0;
  869. }
  870.  
  871. /****************************************************************/
  872.  
  873. beep()
  874. {
  875.     printf("\a");
  876. }
  877.  
  878. /*****************************************************************
  879. * FUNC: int    clip(int num, int min, int max)
  880. * 
  881. * DESC: Clip the number to a value between min and max, inclusive.
  882. *****************************************************************/
  883.  
  884. int
  885. clip(int num, int min, int max)
  886. {
  887.     if (num < min)
  888.         num = min;
  889.     else if (num > max)
  890.         num = max;
  891.  
  892.     return num;
  893. }
  894.  
  895. /*****************************************************************
  896. * FUNC: int waitForTop() and waitForBottom()
  897. * 
  898. * DESC: These routines wait for the TV scan line to get to the
  899. *        top and the bottom of the screen.
  900. *****************************************************************/
  901.  
  902. #define VID_PORT 0x3da
  903. #define VID_RETRACE 0x8  
  904.  
  905. waitForTop()
  906. {
  907.     /* wait till retrace ends */
  908.     while(_inp(VID_PORT) & VID_RETRACE);
  909. }
  910. waitForBottom()
  911. {
  912.     /* wait till next retrace starts*/
  913.     while(!(_inp(VID_PORT) & VID_RETRACE));
  914. }
  915.  
  916. /*****************************************************************
  917. * FUNC: int    wait(int count)
  918. * 
  919. * DESC: Wait for a number of screen refreshes, based on count.
  920. *****************************************************************/
  921.  
  922. int
  923. wait (int count)
  924. {
  925.     int i;
  926.  
  927.     if (!count)
  928.         return 0;
  929.     for (i = 1; i < 2 * count; i++) {
  930.         waitForBottom();
  931.         waitForTop();
  932.     }
  933. }
  934.  
  935. /*****************************************************************
  936. * FUNC: void    setGraphicsMode()
  937. * 
  938. * DESC: Set up the graphics screen
  939. *****************************************************************/
  940.  
  941. void
  942. setGraphicsMode()
  943. {
  944.     _setvideomode(_MRES256COLOR);
  945.     CurrentPal = 0;                /* Force a new palette */
  946. }
  947.  
  948. /*****************************************************************
  949. * FUNC: void    setTextMode()
  950. * 
  951. * DESC: Set the screen to the startup text mode
  952. *****************************************************************/
  953.  
  954. void
  955. setTextMode()
  956. {
  957.     CurrentPal = 0;                /* Force a new palette */
  958.     _setvideomode(_DEFAULTMODE);
  959. }
  960.  
  961. /*****************************************************************
  962. * FUNC: void    quit(int err, char *name)
  963. * 
  964. * DESC: Turn text back on, print the error message and quit.
  965. *****************************************************************/
  966.  
  967. void
  968. quit(ERR err, char *name)
  969. {
  970.     static char *ErrMess[] = {
  971.         " ",
  972.         "I can't get enough memory. Try turning off some TSR's.",
  973.         "I can't find the file",
  974.         "I can't read the file",
  975.         "I can't open the file",
  976.         "I can't write the file",
  977.         "You must install a mouse driver to run this program.",
  978.         "This is the wrong PCX type - I can't read the file",
  979.     };
  980.     
  981.     setTextMode();
  982.     if (err != NO_ERROR) {
  983.         printf ("Error #%d:\n", err);
  984.         printf ("%s %s\n", ErrMess[err], name);
  985.         exit (err);
  986.     }
  987.     exit (0);
  988. }
  989.  
  990.  
  991.